package com.iwuke.dance.util;

import android.Manifest;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.graphics.drawable.GradientDrawable;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.provider.Settings;
import android.text.Editable;
import android.text.InputFilter;
import android.text.Spanned;
import android.text.TextUtils;
import android.text.TextWatcher;
import android.util.Log;
import android.util.TypedValue;
import android.view.View;
import android.view.WindowInsets;
import android.view.WindowInsetsController;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import com.iwuke.dance.util.time_selector.CustomDatePicker;
import com.iwuke.dance.util.time_selector.CustomDatePicker2;
import com.scwang.smart.refresh.layout.api.RefreshLayout;

import java.io.Serializable;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import androidx.core.app.ActivityCompat;

public class Util {

    public static int withdrawStart;//1 余额提现，2 星光值提现
    public static String withdrawAccount;//提现金额
    public static String password;//密码
    public static OnTime onTime;
    public static Map<String,String> userInfoMap = new HashMap<>();
    private static OnStartAndEnd onStartAndEnd;
    public static int REQUEST_SELECT_IMAGES_CODE = 0x01;

    public static void setRefreshlayout(RefreshLayout refreshlayout){
        if (refreshlayout==null){
            return;
        }
        refreshlayout.finishRefresh();//下来加载
        refreshlayout.finishLoadMore();//上拉刷新
        refreshlayout.setNoMoreData(false);//没有更多数据了
    }
    public static boolean isActivity(Activity activity){
        if (activity==null||activity.isFinishing()||activity.isDestroyed()){
            return true;
        }else {
            return false;
        }
    }

    /**
     * @description 获取手机厂商
     * @param
     */
    public static String getDeviceBrand() {
        return Build.BRAND;
    }

    /**
     * @description 获取手机型号
     * @param
     */
    public static String getSystemModel() {
        return Build.MODEL;
    }

    public static boolean isHuaweiDevice() {
        return Build.MANUFACTURER.equalsIgnoreCase("HUAWEI");
    }


    /**
     * @description java去除字符串中的空格、回车、换行 符、制表符
     * @param
     */
    public static String replaceBlank(String str) {

        String dest = "";

        if (str!=null) {

            Pattern p = Pattern.compile("\\s*|\t|\r|\n");

            Matcher m = p.matcher(str);

            dest = m.replaceAll("");

        }

        return dest;

    }

    /**
     * @description 空格判断
     * @param
     */
    public static void setEditTextInhibitInputSpeBlank(EditText et_names,int max) {

        InputFilter filter = new InputFilter() {
            @Override
            public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {

                if (source.toString().equals(" ") ) {
                    return "";
                } else {
                    return null;
                }

            }
        };

        et_names.setFilters(new InputFilter[]{filter,new InputFilter.LengthFilter(max)});
    }

    /**
     * @description 计算分钟数
     * @param
     */
    public static String getTimeExpend(String startTime,String endTime){
        //传入字串类型 2022-03-25 15:30:00
        long longStart = 0,longEnd = 0;
        if (!TextUtils.isEmpty(startTime)&&!TextUtils.isEmpty(endTime)){
            longStart = getTimeMillis(startTime); //获取开始时间毫秒数
            longEnd = getTimeMillis(endTime);  //获取结束时间毫秒数
        }else {
            return "";
        }

        long longExpend = longEnd - longStart;  //获取时间差

        //单位天
        long day = longExpend / (1000 * 24 * 60 * 60);
        //单位时
        long hour = (longExpend - day * (1000 * 24 * 60 * 60)) / (1000 * 60 * 60);
        //单位分
        long minute = (longExpend - day * (1000 * 24 * 60 * 60) - hour * (1000 * 60 * 60)) / (1000 * 60);
        //单位秒
        long second = (longExpend - day * (1000 * 24 * 60 * 60) - hour * (1000 * 60 * 60) - minute * (1000 * 60)) / 1000;


        String hours = isTime((int) hour);
        String minutes = isTime((int) minute);
        String seconds = isTime((int) second);
        String time;
        if (day>0){
            String days = isTime((int) day);
            time = days +"天"+hours + "小时" + minutes + "分钟" + seconds+"秒";
        }else {
            time = hours + "小时" + minutes + "分钟" + seconds+"秒";
        }

        LogUtil.logD("++++++++++++++",time+"");
        return time+"";
    }

    public static String isTime(int time) {
        switch (time){
            case 0: case 1: case 2: case 3: case 4:
            case 5:case 6:case 7:case 8:case 9:
                return "0"+time;
            default:
                return time+"";
        }
    }



    public static boolean isLogin(Context context){
        if (context==null||((Activity)context).isFinishing()){
            return false;
        }

//        if(TextUtils.isEmpty(Util.getToken())||"token".equals(Util.getToken())){
//            LoginUtil loginUtil = new LoginUtil((Activity)context, "");
//            loginUtil.openLoginView(new LoginUtil.SucessCallBack() {
//                @Override
//                public void onSucess() {
//                    //成功 ,Class<?> c
//                    //setIntent(context,c);
//                }
//
//                @Override
//                public void onFail() {
//                    ToastUtil.setToast(context,"登录失败");
//                }
//            });
//            return false;
//        }
        return true;
    }

    /**
     * @description 获取版本号
     * @param
     */
    // 在旧系统上，使用原来的字段，但需要用注解忽略过时警告
    @SuppressWarnings("deprecation")
    public static int getVersionCode(Context context) {
        int versioncode = 0;
        try {
            PackageManager pm = context.getPackageManager();
            PackageInfo pi = pm.getPackageInfo(context.getPackageName(), 0);

            // 判断当前设备系统版本是否为 Android 9.0 (API 28) 或更高
            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.P) {
                // 在新系统上调用新的 getLongVersionCode() 方法，并将 long 类型转换为 int
                versioncode = (int) pi.getLongVersionCode();
            } else {
                // 在旧系统上，使用原来的字段，但需要用注解忽略过时警告
                // 在旧系统上，使用原来的字段，但需要用注解忽略过时警告
//                @SuppressWarnings("deprecation")
                versioncode = pi.versionCode;
            }

        } catch (Exception e) {
            Log.e("VersionInfo", "Exception", e);
        }
        return versioncode;
    }

    /**
     * @description 比较大小
     * @param
     */
    public static boolean compareSize(String d1,String d2){
        BigDecimal b1 = new BigDecimal(d1);
        BigDecimal b2 = new BigDecimal(d2);
        if (b1.compareTo(b2)==1){//d1大
            return true;
        }
        return false;
    }

    /**
     * @description 设置背景颜色
     * @param
     */
    @SuppressLint("WrongConstant")
    public static GradientDrawable setShapeColor(int color) {

        float[] floats = {10, 10, 10, 10, 10, 10, 10, 10};
        GradientDrawable drawable = new GradientDrawable();
        drawable.setShape(GradientDrawable.RECTANGLE);
        drawable.setGradientType(GradientDrawable.RECTANGLE);
        drawable.setCornerRadii(floats);
        drawable.setColor(color);

        return drawable;
    }

    /**
     * @description 保留两位小数 进行加法运算
     * @param
     */
    public static double setBigDecimal(double b1,double b2){
        // 进行加法运算
        BigDecimal b3 = new BigDecimal(b1);
        BigDecimal b4 = new BigDecimal(b2);
        double b = b3.add(b4).doubleValue();
        return (double) Math.round(b * 100) / 100;
    }

    /**
     * @description 进行除法运算
     * @param  //doubleValue() 计算不准确，换成 toString()
     */
    public static String setBigDecimal(double d1) {// 进行除法运算
        String d = String.valueOf(d1);
        BigDecimal b1 = new BigDecimal(d);
        BigDecimal b2 = new BigDecimal("10");
        return b1.divide(b2,2, RoundingMode.HALF_UP).toString();
    }

    public static String setBigDecimal(String d1) {// 进行除法运算
        BigDecimal b1 = new BigDecimal(d1);
        BigDecimal b2 = new BigDecimal("10");
        return b1.divide(b2,2,RoundingMode.HALF_UP).toString();
    }

    public static String setBigDecimal4(double d1) {// 进行除法运算
        String d = String.valueOf(d1);
        BigDecimal b1 = new BigDecimal(d);
        BigDecimal b2 = new BigDecimal("100");
        return b1.divide(b2,2,RoundingMode.HALF_UP).toString();
    }

    public static double setBigDecimal2(double d1,double d2) {// 进行除法运算
        if (d1<=0){
            return 0;
        }
        BigDecimal b1 = new BigDecimal(d1);
        BigDecimal b2 = new BigDecimal(d2);
        return b1.divide(b2,2,RoundingMode.HALF_UP).doubleValue();
    }

    /**
     * @description 进行减法运算
     * @param
     */
    public static double setBigDecimal2(double d1) {// 进行减法运算
        BigDecimal b1 = new BigDecimal(d1);
        BigDecimal b2 = new BigDecimal(100);
        return b1.subtract(b2).doubleValue();
    }


    /**
     * @description 乘法运算
     * @param
     */
     public static double setMultiply(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return setRound(b1.multiply(b2).doubleValue(),2);
     }

    public static String setMultiply2(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).toString();
    }

    public static double setMultiply3(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).doubleValue();
    }


     /**
      * @description 提供精确的小数位四舍五入处理。
      * @param v 需要四舍五入的数字 scale 小数点后保留几位
      */
    public static double setRound(double v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(v);
        BigDecimal one = new BigDecimal("1");
        return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue();
    }

    //dp转px
    public static int dip2px(Context context, float dpValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dpValue * scale + 0.5f);
    }

    //px转dp
    public static int px2dip(Context context, int pxValue) {
        if (context==null){
            return 0;
        }
        return ((int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, pxValue, context.getResources().getDisplayMetrics()));
    }

    /**
     * 判断android 状态栏字体颜色
     *true 字体黑色  false  字体白色
     * @return
     */
    // 使用注解忽略此处的过时警告，因为我们已做了版本判断
    @SuppressWarnings("deprecation")
    public static void setAndroidNativeLightStatusBar(Activity activity, boolean dark) {
        View decor = activity.getWindow().getDecorView();
        if (dark) {
//            decor.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR);
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
                // 新API：使用 WindowInsetsController
                WindowInsetsController insetsController = decor.getWindowInsetsController();
                if (insetsController != null) {
                    insetsController.show(WindowInsets.Type.statusBars());
                    insetsController.setSystemBarsAppearance(
                            WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS,
                            WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS
                    );
                }
            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                // 旧API：在 API 23 到 29 的设备上，使用原有方法
                // 使用注解忽略此处的过时警告，因为我们已做了版本判断
                @SuppressWarnings("deprecation")
                int systemUiVisibility = decor.getSystemUiVisibility();
                // 添加 LIGHT_STATUS_BAR 标志
                systemUiVisibility |= View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
                decor.setSystemUiVisibility(systemUiVisibility);
            }
            // 对于 API 23 (M) 以下的设备，无法设置状态栏图标颜色
        } else {
//            decor.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
                // 新API：使用 WindowInsetsController
                WindowInsetsController insetsController = decor.getWindowInsetsController();
                if (insetsController != null) {
                    insetsController.hide(WindowInsets.Type.systemBars());
                    insetsController.setSystemBarsBehavior(WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE);
                }
            } else {
                // 旧API：在 API 30 以下的设备上，使用原有方法设置一组完整的沉浸式标志
                // 使用注解忽略此处的过时警告，因为我们已做了版本判断
                @SuppressWarnings("deprecation")
                int flags = View.SYSTEM_UI_FLAG_LAYOUT_STABLE |
                        View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
                        View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN |
                        View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
                        View.SYSTEM_UI_FLAG_FULLSCREEN |
                        View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
                decor.setSystemUiVisibility(flags);
            }

        }


    }

    /**
     * @description 退出登录前清空必要数据
     * @param
     */
    public static void outLogin(){
//        SharedPreferencesUtil instance = SharedPreferencesUtil.getInstance();
//        instance.setToKen("");//ToKen
//        instance.setProjectName("");//项目名称
//        instance.setProjectId(-1);//项目id
//        MainActivity.getContext().mapJson.clear();//车场初始化
//        instance.setOperatorName("");//操作人名称
//
//        //商户
//        instance.setPhoneNumber("");//账号
//        instance.setPassword("");//密码
//        instance.setMerchantId("");//商户id
//        instance.setCheckBox(false);//状态
        //权限
        userInfoMap.clear();
    }

    public static void setToken(String token,String operatorName){
//        SharedPreferencesUtil instance = SharedPreferencesUtil.getInstance();
//        instance.setToKen(token);
//        instance.setOperatorName(operatorName);
    }

    public static String getToken(){
        SharedPreferencesUtil instance = SharedPreferencesUtil.getInstance();
        String toKen = instance.getToKen("TOKEN");
        return toKen;
    }

    /**
     * @description 跳转页面
     * @param
     */
    public static void setIntent(Context context,Class<?> tClass){
        Intent intent = new Intent(context, tClass);
        context.startActivity(intent);
    }

    public static void setIntent(Context context,Class<?> tClass,String title){
        Intent intent = new Intent(context, tClass);
        intent.putExtra("text", title);
        context.startActivity(intent);
    }

    /**
     * @description 跳转页面
     * @param
     */
    public static void setIntent(Context context, Class<?> tClass, Bundle bundle){
        /*Bundle bundle = new Bundle();
        bundle.putSerializable("data", (Serializable)data);
        intent.putExtras(bundle);*/
        Intent intent = new Intent(context, tClass);
        intent.putExtras(bundle);
        context.startActivity(intent);
        // 使用示例
        //StarlightValueAndBalanceBean bean = Util.getSerializableSafe(getIntent(), "data", StarlightValueAndBalanceBean.class);

    }

    // 定义一个通用的工具方法
    @SuppressWarnings({"deprecation", "unchecked"})
    public static <T extends Serializable> T getSerializableSafe(Intent intent, String key, Class<T> clazz) {
        if (intent == null || key == null || clazz == null) {
            return null;
        }

        try {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                return intent.getSerializableExtra(key, clazz);
            } else {
                Serializable result = intent.getSerializableExtra(key);
                if (clazz.isInstance(result)) {
                    return (T) result;
                }
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }



    /**
     * 只能输入两位小数
     */
    public static void setEditText(EditText editText){

        editText.addTextChangedListener(new TextWatcher() {
            public void afterTextChanged(Editable edt) {
                String temp = edt.toString();
                int posDot = temp.indexOf(".");
                if (posDot <= 0) return;
                if (temp.length() - posDot - 1 > 2) {
                    edt.delete(posDot + 3, posDot + 4);
                }
            }

            public void beforeTextChanged(CharSequence arg0, int arg1, int arg2, int arg3) {}

            public void onTextChanged(CharSequence arg0, int arg1, int arg2, int arg3) {}
        });

    }

    /**
     * 隐藏键盘
     *当前activity
     * @param context
     */
    public static void hideIme(Activity context) {
        if (context == null)
            return;
        final View v = context.getWindow().peekDecorView();
        if (v != null && v.getWindowToken() != null) {
            InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
        }
    }

    /**
     * 隐藏键盘
     *v 点击事件的 onClick(View v)
     * 虽然是EditText调起键盘，但是任意的一个控件的点击事件v都可以隐藏
     * @param context
     */
    public static void hideIme(Context context,View v) {
        InputMethodManager imm = (InputMethodManager)
                context.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
    }

//    public static void setImagePicker(Context context, ArrayList<String> mImageList){
//        if (mImageList==null){
//            return;
//        }
//        if (RequestPermissions.checkPermissionCamera(context)){
//            ImagePicker.getInstance()
//                    .setTitle(context.getString(R.string.app_name))//设置标题
//                    .showCamera(true)//设置是否显示拍照按钮
//                    .showImage(true)//设置是否展示图片
//                    .showVideo(false)//设置是否展示视频
//                    //.filterGif(false)//设置是否过滤gif图片
//                    .setSingleType(true)//设置图片视频不能同时选择
//                    .setMaxCount(1)//设置最大选择图片数目(默认为1，单选)
//                    .setImagePaths(mImageList)//保存上一次选择图片的状态，如果不需要可以忽略
//                    .setImageLoader(new GlideLoader())//设置自定义图片加载器
//                    .start((Activity) context, REQUEST_SELECT_IMAGES_CODE);//REQEST_SELECT_IMAGES_CODE为Intent调用的requestCode
//
//        }
//    }

    /**
     * @description 日期三月内：true  外：false
     * @param
     */
    public static boolean getTime(String start,String end){
        String[] s = start.split("-");
        String[] e = end.split("-");
        int startY = Integer.parseInt(s[0]);
        int startM = Integer.parseInt(s[1]);
        int startD = Integer.parseInt(s[2]);

        int endY = Integer.parseInt(e[0]);
        int endM = Integer.parseInt(e[1]);
        int endD = Integer.parseInt(e[2]);

        if (startY==endY){
            if ((endM-startM)>3){
                return false;
            }else if ((endM-startM)==3){
                if ((endD-startD)>0){
                    return false;
                }
                return true;
            }else {
                return true;
            }
        }else {
            if ((12-startM)+endM>3){
                return false;
            }else if ((12-startM)+endM==3){
                if ((endD-startD)>0){
                    return false;
                }
                return true;
            }else {
                return true;
            }
        }

//        if (!TextUtils.isEmpty(s[0])){
//            int startY = Integer.parseInt(s[0]);
//        }
//
//        if (!TextUtils.isEmpty(s[1])){
//            int startM = Integer.parseInt(s[1]);
//        }
//
//        if (!TextUtils.isEmpty(s[2])){
//            int startD = Integer.parseInt(s[2]);
//        }
    }

    /**
     * @description 指定日期相加减
     * @param num 加减天数
     */
    public static String getDate(int num){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd", Locale.CHINA);
        //String source = "2019-06-10";//指定日期
        String source = sdf.format(new Date());//当前日期
        try {
            Date date = sdf.parse(source);
            Calendar rightNow = Calendar.getInstance();
            rightNow.setTime(date);
            rightNow.add(Calendar.DAY_OF_YEAR, num);
            Date time = rightNow.getTime();
            String format = sdf.format(time);
            return format;
            //2019-06-10减60天为：2019-04-11
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * @description 计算分钟数
     * @param
     */
    public static long getTimeExpend(String startTime){
        //传入字串类型 2022-03-25 15:30:00
        long longStart;
        if (!TextUtils.isEmpty(startTime)){
            longStart = getTimeMillis(startTime); //获取开始时间毫秒数
        }else {
            longStart = getTimeMillis("2022-03-25 15:30:00"); //获取开始时间毫秒数
        }
        long longEnd = getCurTimeLong();  //获取结束时间毫秒数
        long longExpend = longEnd - longStart;  //获取时间差

        long longHours = longExpend / (60 * 1000); //根据时间差来计算分钟数
        LogUtil.logD("++++++++++++++",longHours+"");
        return longHours;
    }

    /**
     * @description yyyy-MM-dd HH:mm:ss 转成时间戳
     * @param
     */
    private static long getTimeMillis(String strTime) {
        long returnMillis = 0;
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);
        Date d = null;
        try {
            d = sdf.parse(strTime);
            returnMillis = d.getTime();
        } catch (ParseException e) {
            LogUtil.logD("++++++++++++++++",e.toString());
        }
        return returnMillis;
    }

    /**
     * 时间戳转换成字符窜
     * @param milSecond
     * @param
     * @return
     */
    public static String getDateToString(long milSecond) {
        long curTimeLong = getCurTimeLong()+(milSecond*60*60*1000);

        Date date = new Date(curTimeLong);
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);
        return format.format(new Date())+"~"+format.format(date);
    }

    /**
     * 获取系统时间戳
     * @return
     */
    public static long getCurTimeLong(){
        long time=System.currentTimeMillis();
        return time;
    }

    public static String setTime(){
        //yyyy-MM-dd HH:mm
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);
        //获取当前时间
        String now = sdf.format(new Date());
        return now;
    }

    public static String setTime2(){
        //yyyy-MM-dd HH:mm
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.CHINA);
        //获取当前时间
        String now = sdf.format(new Date());
        return now;
    }

    public static String setTime3(){
        //yyyy-MM-dd HH:mm
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd", Locale.CHINA);
        //获取当前时间
        String now = sdf.format(new Date());
        return now;
    }

    /**
     * 判断2个时间大小
     * yyyy-MM-dd HH:mm 格式（自己可以修改成想要的时间格式）
     * @param startTime
     * @param endTime
     * @return
     */
    public static String timeCompare(String startTime, String endTime){
        String i=startTime;
        //注意：传过来的时间格式必须要和这里填入的时间格式相同
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);
        try {
            Date date1 = dateFormat.parse(startTime);//开始时间
            Date date2 = dateFormat.parse(endTime);//结束时间
            // 1 结束时间小于开始时间 2 开始时间与结束时间相同 3 结束时间大于开始时间
            if (date2.getTime()<date1.getTime()){
                //结束时间小于开始时间
                i= startTime;
            }else if (date2.getTime()==date1.getTime()){
                //开始时间与结束时间相同
                i= startTime;
            }else if (date2.getTime()>date1.getTime()){
                //结束时间大于开始时间
                i= endTime;
            }
        } catch (Exception e) {

        }
        return  i;
    }

    public static int timeCompare2(String startTime, String endTime){
        int i=0;
        //注意：传过来的时间格式必须要和这里填入的时间格式相同
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);
        try {
            Date date1 = dateFormat.parse(startTime);//开始时间
            Date date2 = dateFormat.parse(endTime);//结束时间
            // 1 结束时间小于开始时间 2 开始时间与结束时间相同 3 结束时间大于开始时间
            if (date2.getTime()<date1.getTime()){
                //结束时间小于开始时间
                i= 0;
            }else if (date2.getTime()==date1.getTime()){
                //开始时间与结束时间相同
                i= 0;
            }else if (date2.getTime()>date1.getTime()){
                //结束时间大于开始时间
                i= 1;
            }
        } catch (Exception e) {

        }
        return  i;
    }

    /**
     * 显示时间
     */
    public static void datePicker(Context context) {
        String birthday;
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.CHINA);
        //获取当前时间
        String now = sdf.format(new Date());
        //tvElectricalTime.setText(now.split(" ")[0]);
//        final String s = tv_birthday.getText().toString();
//        if (s != null && !s.equals("")) {
//            birthday = s + " 00:00";//生日
//        } else {
//            birthday = now;//当前时间
//        }
        CustomDatePicker2 customDatePicker = new CustomDatePicker2(context, new CustomDatePicker2.ResultHandler() {
            @Override
            public void handle(Map<String,String> map) { // 回调接口，获得选中的时间
                if (onStartAndEnd!=null){
                    onStartAndEnd.onStartAndEnd(map);
                }
            }
        }, "2000-01-01 00:00", now); // 初始化日期格式请用：yyyy-MM-dd HH:mm，否则不能正常运行
        customDatePicker.showSpecificTime(false); // 不显示时和分
        customDatePicker.setIsLoop(false); // 不允许循环滚动
        customDatePicker.show(now);
    }

    /**
     * @description 选择时间
     * @param
     * @return
     * @author 魏从响
     * @time 2025/10/15 13:32
     */
    public static void customDatePicker(Context context,String title) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.CHINA);
        //获取当前时间
        String now = sdf.format(new Date());

        CustomDatePicker customDatePicker = new CustomDatePicker(context, (time)-> {
            if (onTime!=null){
                onTime.onTime(time);
            }
        }, "2000-01-01 00:00", now); // 初始化日期格式请用：yyyy-MM-dd HH:mm，否则不能正常运行
        customDatePicker.setTitle(title==null?"选择时间":title);
        customDatePicker.showSpecificTime(false); // 不显示时和分
        customDatePicker.setIsLoop(false); // 不允许循环滚动
        customDatePicker.show(now);
    }


    public static void setOnStartAndEnd(OnStartAndEnd onStartAndEnd){

        Util.onStartAndEnd = onStartAndEnd;
    }


    public static void setTextString(TextView text_view, String string) {
        if (!TextUtils.isEmpty(string)) {
            text_view.setText(string);
        }else {
            text_view.setText("");
        }
    }

    public interface OnStartAndEnd{
        void onStartAndEnd(Map<String,String> map);
    }

    public static void getOnTime(OnTime onTime){

        Util.onTime = onTime;
    }
    public interface OnTime{
        void onTime(String onTime);
    }

    /**
     * 得到指定月的天数
     * */
    public static int getMonthLastDay(int year, int month)
    {
        Calendar a = Calendar.getInstance();
        a.set(Calendar.YEAR, year);
        a.set(Calendar.MONTH, month - 1);
        a.set(Calendar.DATE, 1);//把日期设置为当月第一天
        a.roll(Calendar.DATE, -1);//日期回滚一天，也就是最后一天
        int maxDate = a.get(Calendar.DATE);
        return maxDate;
    }


    public static void callPhone(Context context,String callPhone){
        if (PackageManager.PERMISSION_GRANTED != ActivityCompat.checkSelfPermission(context, Manifest.permission.CALL_PHONE)) {
            ActivityCompat.requestPermissions((Activity) context, new String[]{Manifest.permission.CALL_PHONE}, 0x0010);
        } else {
            /**
             * 拨打电话（直接拨打电话）
             */
            //拨打电话（跳转到拨号界面，用户手动点击拨打）
            //Intent intent = new Intent(Intent.ACTION_DIAL);
            //拨打电话（直接拨打电话）
            Intent intent = new Intent(Intent.ACTION_CALL);
            Uri data = Uri.parse("tel:" + callPhone);
            intent.setData(data);
            context.startActivity(intent);
        }
    }

    /**
     * 设置edittext最大的输入限制
     * @param editText
     * @param
     */
    public static void setMaxLength(Context context,EditText editText,TextView tv_content_length, int length){
        setMaxLength(context,editText,tv_content_length,length,null);
    }
    public static void setMaxLength(Context context,final EditText editText,TextView tv_content_length, final int length,String type){
        editText.addTextChangedListener(new TextWatcher() {
//Util.setMaxLength(FeedbackActivity.this,et_content,tv_content_length, 50);//限制内容长度
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {

            }

            @Override
            public void onTextChanged(CharSequence charSequence, int start, int before, int count) {

                if (charSequence.length()<(length+1)){
                    if (tv_content_length!=null)
                        tv_content_length.setText(charSequence.length()+"/"+length);
                }else if (charSequence.length()==(length+1)){
                    if (TextUtils.isEmpty(type)){
                        deleteChar(editText);
                    }else {
                        editText.setText(editText.getText().toString().substring(0, length));
                    }
                    //editText.setText(editText.getText().toString().substring(0, length));

                    if (tv_content_length!=null)
                        tv_content_length.setText(charSequence.length()+"/"+length);
                    editText.setSelection(editText.getText().toString().length());//将光标移至文字末尾
                    //ToastUtil.setToast(context,"限"+length+"字符");
                    Toast.makeText(context,"限"+length+"字符",Toast.LENGTH_SHORT).show();
                }
            }

            @Override
            public void afterTextChanged(Editable s) {

            }
        });
    }

    private static void deleteChar(EditText editText){
        int index = editText.getSelectionStart();
        Editable editable = editText.getText();
        editable.delete(index-1, index);
    }

    /**
     * @description 手机号验证
     * @param
     */
    public static boolean isPhoneNumber(String input) {// 判断手机号码是否规则
        if (TextUtils.isEmpty(input)){
            return false;
        }
        //"[1]"代表第1位为数字1，"[0-9]"代表第二位可以为0~9中的一个，"\\d{9}"代表后面是可以是0～9的数字，有9位。
        String regex = "(1[0-9])\\d{9}";
        Pattern p = Pattern.compile(regex);
        return p.matches(regex, input);//如果不是号码，则返回false，是号码则返回true

    }

    /**
     * 获取本地软件版本号名称
     */
    public static String getLocalVersionName(Context ctx) {
        String localVersion = "";
        try {
            PackageInfo packageInfo = ctx.getApplicationContext()
                    .getPackageManager()
                    .getPackageInfo(ctx.getPackageName(), 0);
            localVersion = packageInfo.versionName;
            Log.d("TAG", "当前版本名称：" + localVersion);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return localVersion;
    }

    /**
     * @description 获取androidId
     * @param
     * @return
     * @author 魏从响
     * @time 2025/10/18 14:44
     */
    @SuppressLint("HardwareIds") // 明确忽略警告，表明你已了解风险
    public static String getAndroidId (Context context) {
        try {
            String androidId = Settings.Secure.getString(
                    context.getContentResolver(),
                    Settings.Secure.ANDROID_ID
            );

            // 处理获取失败的情况
            if (androidId == null || "9774d56d682e549c".equals(androidId)) {
                // 返回默认值或使用备用方案
                return "default_id_or_use_fallback";
            }

            return androidId;
        } catch (Exception e) {
            e.printStackTrace();
            return "error_fallback_id";
        }
//        String ANDROID_ID = Settings.System.getString(context.getContentResolver(), Settings.System.ANDROID_ID);
//        return ANDROID_ID;
    }

    /**
     * @description 空格过滤
     * @param
     */
    public static String removeSpace(String s) {

        if (TextUtils.isEmpty(s)){
            return "";
        }
        String regex = "\\s";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(s);
        return matcher.replaceAll("");
    }

}
